@s-hirano-ist/s-scripts 1.26.7 → 4.0.0

package/README.md

@@ -2,6 +2,8 @@
 
 CLI scripts for s-private data operations.
 
+The npm artifact bundles the required internal workspace code and generated Prisma client. Consumers install only this CLI package; internal s-private packages are not separate npm dependencies. Command names remain unchanged.
+
 ## Installation
 
 ```sh

package/dist/chunk-5OXUZW2Q.js

@@ -0,0 +1,590 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  createWebpThumbnail,
+  readImageMetadata
+} from "./chunk-KKZP7ZF3.js";
+import {
+  createMinioClient,
+  createStorageService
+} from "./chunk-F4J6JBR4.js";
+import {
+  CreatedAt,
+  ExportedStatus,
+  Id,
+  LastUpdatedStatus,
+  UnexportedStatus,
+  UserId,
+  createPrismaClient,
+  import_generated,
+  makeId,
+  withTransactionRetry
+} from "./chunk-IWNZQXDG.js";
+import {
+  createPushoverService
+} from "./chunk-7PVU2Z32.js";
+
+// ../core/shared-kernel/entities/file-entity.ts
+import { z } from "zod";
+var Path = z.string().min(1).max(512, { message: "tooLong" }).brand();
+var ContentType = z.enum(["image/jpeg", "image/png", "image/webp", "jpeg", "png", "webp"]).brand();
+var FileSize = z.number().int().nonnegative().max(10 * 1024 * 1024).brand();
+
+// ../core/shared-kernel/services/entity-factory.ts
+import { ZodError } from "zod";
+
+// ../core/shared-kernel/services/url-validation.ts
+var isValidHttpUrl = (url) => {
+  if (!url) return true;
+  try {
+    const urlObject = new URL(url);
+    return urlObject.protocol === "http:" || urlObject.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+
+// ../core/books/entities/book-entity.ts
+import { z as z2 } from "zod";
+var ISBN = z2.string({ message: "required" }).min(1, { message: "required" }).transform((v) => v.replaceAll("-", "")).pipe(
+  z2.string().regex(/^\d{13}$/u, { message: "invalidFormat" }).brand()
+);
+var makeISBN = (v) => ISBN.parse(v);
+var BookTitle = z2.string({ message: "required" }).min(1, { message: "required" }).max(512, { message: "tooLong" }).brand();
+var GoogleSubtitle = z2.string().max(512, { message: "tooLong" }).nullable().brand();
+var GoogleAuthors = z2.array(z2.string()).nullable().brand();
+var GoogleDescription = z2.string().nullable().brand();
+var GoogleImgSrc = z2.string().max(1024, { message: "tooLong" }).refine(isValidHttpUrl, { message: "invalidFormat" }).nullable().brand();
+var GoogleHref = z2.string().max(1024, { message: "tooLong" }).refine(isValidHttpUrl, { message: "invalidFormat" }).nullable().brand();
+var Rating = z2.number({ message: "required" }).int({ message: "invalidFormat" }).min(1, { message: "outOfRange" }).max(5, { message: "outOfRange" }).brand();
+var Tags = z2.array(
+  z2.string().min(1, { message: "required" }).max(64, { message: "tooLong" })
+).brand();
+var BookMarkdown = z2.string().nullable().brand();
+var Base = z2.object({
+  id: Id,
+  userId: UserId,
+  isbn: ISBN,
+  title: BookTitle,
+  rating: Rating,
+  tags: Tags.optional(),
+  googleSubTitle: GoogleSubtitle.optional(),
+  googleAuthors: GoogleAuthors.optional(),
+  googleDescription: GoogleDescription.optional(),
+  googleImgSrc: GoogleImgSrc.optional(),
+  googleHref: GoogleHref.optional(),
+  imagePath: Path.optional(),
+  markdown: BookMarkdown.optional(),
+  createdAt: CreatedAt
+});
+var UnexportedBook = Base.extend({ status: UnexportedStatus });
+var LastUpdatedBook = Base.extend({ status: LastUpdatedStatus });
+var ExportedBook = Base.extend(ExportedStatus.shape);
+
+// ../infrastructure/dist/content/sharp-image-processor.js
+var THUMBNAIL_WIDTH = 192;
+var THUMBNAIL_HEIGHT = 192;
+async function createThumbnail(bytes, width = THUMBNAIL_WIDTH, height = THUMBNAIL_HEIGHT) {
+  return await createWebpThumbnail(bytes, { width, height });
+}
+async function getMetadata(bytes) {
+  return await readImageMetadata(bytes);
+}
+var sharpImageProcessor = {
+  createThumbnail,
+  getMetadata
+};
+
+// ../application/dist/content/models.js
+import { z as z3 } from "zod";
+var contentDomainSchema = z3.enum([
+  "articles",
+  "notes",
+  "images",
+  "books"
+]);
+var syncDomainSchema = z3.enum([
+  "articles",
+  "notes",
+  "images",
+  "books",
+  "categories"
+]);
+var statusSchema = z3.enum(["UNEXPORTED", "LAST_UPDATED", "EXPORTED"]);
+var idSchema = z3.string().min(1).max(512);
+var contentBase = {
+  id: idSchema,
+  status: statusSchema,
+  createdAt: z3.date(),
+  updatedAt: z3.date(),
+  exportedAt: z3.date().nullable()
+};
+var articleSchema = z3.object({
+  ...contentBase,
+  title: z3.string(),
+  url: z3.url(),
+  quote: z3.string().nullable(),
+  categoryId: idSchema,
+  categoryName: z3.string(),
+  ogImageUrl: z3.string().nullable().optional(),
+  ogTitle: z3.string().nullable().optional(),
+  ogDescription: z3.string().nullable().optional()
+});
+var noteSchema = z3.object({
+  ...contentBase,
+  title: z3.string(),
+  markdown: z3.string()
+});
+var imageSchema = z3.object({
+  ...contentBase,
+  path: z3.string(),
+  contentType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  fileSize: z3.number().int().nonnegative().nullable(),
+  width: z3.number().int().positive().nullable(),
+  height: z3.number().int().positive().nullable()
+});
+var bookSchema = z3.object({
+  ...contentBase,
+  isbn: z3.string(),
+  title: z3.string(),
+  markdown: z3.string().nullable(),
+  imagePath: z3.string().nullable(),
+  googleSubTitle: z3.string().nullable().optional(),
+  googleAuthors: z3.array(z3.string()).optional(),
+  googleDescription: z3.string().nullable().optional(),
+  googleImgSrc: z3.string().nullable().optional(),
+  googleHref: z3.string().nullable().optional(),
+  rating: z3.number().int(),
+  tags: z3.array(z3.string())
+});
+var categorySchema = z3.object({ id: idSchema, name: z3.string() });
+
+// ../application/dist/batch/import-models.js
+var importSchemas = {
+  articles: articleSchema.pick({
+    title: true,
+    url: true,
+    quote: true,
+    categoryName: true,
+    ogImageUrl: true,
+    ogTitle: true,
+    ogDescription: true
+  }),
+  notes: noteSchema.pick({ title: true, markdown: true }),
+  images: imageSchema.pick({
+    path: true,
+    contentType: true,
+    fileSize: true,
+    width: true,
+    height: true
+  }),
+  books: bookSchema.pick({
+    isbn: true,
+    title: true,
+    markdown: true,
+    imagePath: true,
+    googleSubTitle: true,
+    googleAuthors: true,
+    googleDescription: true,
+    googleImgSrc: true,
+    googleHref: true,
+    rating: true,
+    tags: true
+  })
+};
+function importKey(values) {
+  if ("url" in values)
+    return values.url;
+  if ("isbn" in values)
+    return values.isbn;
+  if ("path" in values)
+    return values.path;
+  return values.title;
+}
+function importChange(domain, id, values) {
+  switch (domain) {
+    case "articles":
+      return { domain, id, values: importSchemas.articles.parse(values) };
+    case "notes":
+      return { domain, id, values: importSchemas.notes.parse(values) };
+    case "images":
+      return { domain, id, values: importSchemas.images.parse(values) };
+    case "books":
+      return { domain, id, values: importSchemas.books.parse(values) };
+  }
+  throw new Error("Unsupported content domain");
+}
+
+// ../core/articles/entities/article-entity.ts
+import { z as z4 } from "zod";
+var CategoryName = z4.string({ message: "required" }).trim().min(1, { message: "required" }).max(16, { message: "tooLong" }).brand();
+var ArticleTitle = z4.string({ message: "required" }).min(1, { message: "required" }).max(128, { message: "tooLong" }).brand();
+var Quote = z4.string().max(512, { message: "tooLong" }).nullable().optional().brand();
+var Url = z4.url({ message: "invalidFormat" }).min(1, { message: "required" }).max(1024, { message: "tooLong" }).refine(isValidHttpUrl, { message: "invalidFormat" }).brand();
+var OgTitle = z4.string().max(512, { message: "tooLong" }).nullable().optional().brand();
+var OgDescription = z4.string().max(1024, { message: "tooLong" }).nullable().optional().brand();
+var OgImageUrl = z4.string().max(1024, { message: "tooLong" }).refine(isValidHttpUrl, { message: "invalidFormat" }).nullable().optional().brand();
+var Base2 = z4.object({
+  id: Id,
+  userId: UserId,
+  categoryId: Id,
+  title: ArticleTitle,
+  quote: Quote,
+  url: Url,
+  createdAt: CreatedAt,
+  ogTitle: OgTitle,
+  ogDescription: OgDescription,
+  ogImageUrl: OgImageUrl
+});
+var UnexportedArticle = Base2.extend({ status: UnexportedStatus });
+var LastUpdatedArticle = Base2.extend({ status: LastUpdatedStatus });
+var ExportedArticle = Base2.extend(ExportedStatus.shape);
+
+// ../core/notes/entities/note-entity.ts
+import { z as z5 } from "zod";
+var NoteTitle = z5.string({ message: "required" }).min(1, { message: "required" }).max(64, { message: "tooLong" }).brand();
+var Markdown = z5.string({ message: "required" }).min(1, { message: "required" }).brand();
+var Base3 = z5.object({
+  id: Id,
+  userId: UserId,
+  title: NoteTitle,
+  markdown: Markdown,
+  createdAt: CreatedAt
+});
+var UnexportedNote = Base3.extend({ status: UnexportedStatus });
+var LastUpdatedNote = Base3.extend({ status: LastUpdatedStatus });
+var ExportedNote = Base3.extend(ExportedStatus.shape);
+
+// ../application/dist/batch/validate-import.js
+function validateImport(change) {
+  switch (change.domain) {
+    case "articles":
+      ArticleTitle.parse(change.values.title);
+      Url.parse(change.values.url);
+      CategoryName.parse(change.values.categoryName);
+      Quote.parse(change.values.quote);
+      OgTitle.parse(change.values.ogTitle);
+      OgDescription.parse(change.values.ogDescription);
+      OgImageUrl.parse(change.values.ogImageUrl);
+      break;
+    case "notes":
+      NoteTitle.parse(change.values.title);
+      Markdown.parse(change.values.markdown);
+      break;
+    case "books":
+      ISBN.parse(change.values.isbn);
+      BookTitle.parse(change.values.title);
+      Rating.parse(change.values.rating);
+      Tags.parse(change.values.tags);
+      break;
+    case "images":
+      Path.parse(change.values.path);
+      break;
+  }
+}
+
+// ../application/dist/error.js
+var ApplicationError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "ApplicationError";
+  }
+};
+
+// ../application/dist/batch/synchronize-content.js
+function preserveCover(change, item, previous) {
+  if (item.preserveImagePath && change.domain === "books" && previous && "imagePath" in previous.values)
+    return {
+      ...change,
+      values: { ...change.values, imagePath: previous.values.imagePath }
+    };
+  return change;
+}
+async function saveItem(owner, change, item, creating, deps) {
+  if (item.media && (change.domain === "images" || change.domain === "books")) {
+    if (!deps.media)
+      throw new ApplicationError("UNAVAILABLE");
+    await deps.media.put(change.domain, item.media.path, item.media.bytes);
+  }
+  await deps.repository.save(owner, change, creating, deps.clock.now());
+}
+async function prune(domain, owner, records, present, deps, options) {
+  let deletedCount = 0;
+  for (const record of records) {
+    if (record.status !== "EXPORTED" || present.has(record.key))
+      continue;
+    const count = options.dryRun ? 1 : await deps.repository.deleteExported(domain, owner, record.id);
+    if (count && !options.dryRun && domain === "images" && deps.media && !await deps.repository.isMediaReferenced(record.key))
+      await deps.media.removeImage(record.key);
+    deletedCount += count;
+    if (count)
+      options.onProgress?.({ action: "deleted", key: record.key });
+  }
+  return deletedCount;
+}
+async function synchronizeContent(domain, owner, source, deps, options) {
+  const records = await deps.repository.list(domain, owner);
+  const existing = new Map(records.map((record) => [record.key, record]));
+  const present = /* @__PURE__ */ new Set();
+  const summary = {
+    insertedCount: 0,
+    updatedCount: 0,
+    skippedCount: 0,
+    deletedCount: 0
+  };
+  for await (const item of source) {
+    let change = importChange(domain, "", item.values);
+    validateImport(change);
+    const key = importKey(change.values);
+    present.add(key);
+    const previous = existing.get(key);
+    change = preserveCover(change, item, previous);
+    if (previous && (domain === "images" || JSON.stringify(previous.values) === JSON.stringify(change.values))) {
+      summary.skippedCount++;
+      options.onProgress?.({ action: "skipped", key });
+      continue;
+    }
+    change = { ...change, id: previous?.id ?? makeId() };
+    if (!options.dryRun)
+      await saveItem(owner, change, item, !previous, deps);
+    existing.set(key, {
+      id: change.id,
+      key,
+      status: previous?.status ?? "EXPORTED",
+      values: change.values
+    });
+    if (previous)
+      summary.updatedCount++;
+    else
+      summary.insertedCount++;
+    options.onProgress?.({ action: previous ? "updated" : "inserted", key });
+  }
+  summary.deletedCount = await prune(domain, owner, records, present, deps, options);
+  return summary;
+}
+
+// ../infrastructure/dist/persistence-errors.js
+async function withPersistenceErrors(work, duplicate = "DUPLICATE") {
+  try {
+    return await work();
+  } catch (error) {
+    if (error instanceof import_generated.Prisma.PrismaClientKnownRequestError) {
+      if (error.code === "P2002")
+        throw new ApplicationError(duplicate);
+      if (error.code === "P2025")
+        throw new ApplicationError("NOT_FOUND");
+    }
+    throw error;
+  }
+}
+
+// ../infrastructure/dist/batch/content-import-repository.js
+import { z as z6 } from "zod";
+async function categoryId(tx, owner, name, now) {
+  const existing = await tx.category.findUnique({
+    where: { name_userId: { name, userId: owner } },
+    select: { id: true }
+  });
+  if (existing)
+    return existing.id;
+  const created = await tx.category.create({
+    data: { id: makeId(), name, userId: owner, createdAt: now },
+    select: { id: true }
+  });
+  return created.id;
+}
+function createContentImportRepository(prisma) {
+  return {
+    async list(domain, owner) {
+      let rows;
+      switch (domain) {
+        case "articles":
+          rows = (await prisma.article.findMany({
+            where: { userId: owner },
+            include: { Category: { select: { name: true } } }
+          })).map(({ Category, ...row }) => Object.assign(row, { categoryName: Category.name }));
+          break;
+        case "notes":
+          rows = await prisma.note.findMany({ where: { userId: owner } });
+          break;
+        case "books":
+          rows = await prisma.book.findMany({ where: { userId: owner } });
+          break;
+        case "images":
+          rows = await prisma.image.findMany({ where: { userId: owner } });
+          break;
+      }
+      return rows.map((row) => {
+        const { id, status } = z6.object({ id: z6.string(), status: statusSchema }).parse(row);
+        const change = importChange(domain, id, row);
+        return {
+          id,
+          status,
+          key: importKey(change.values),
+          values: change.values
+        };
+      });
+    },
+    async save(owner, change, creating, now) {
+      await withPersistenceErrors(() => withTransactionRetry(() => prisma.$transaction(async (tx) => {
+        const where = { id: change.id, userId: owner };
+        const base = {
+          id: change.id,
+          userId: owner,
+          status: "EXPORTED",
+          createdAt: now,
+          exportedAt: now
+        };
+        switch (change.domain) {
+          case "articles": {
+            const { categoryName, ...values } = change.values;
+            const category = await categoryId(tx, owner, categoryName, now);
+            const data = { ...values, categoryId: category };
+            if (creating)
+              await tx.article.create({ data: { ...base, ...data } });
+            else
+              await tx.article.update({ where, data });
+            break;
+          }
+          case "notes":
+            if (creating)
+              await tx.note.create({ data: { ...base, ...change.values } });
+            else
+              await tx.note.update({ where, data: change.values });
+            break;
+          case "books":
+            if (creating)
+              await tx.book.create({ data: { ...base, ...change.values } });
+            else
+              await tx.book.update({ where, data: change.values });
+            break;
+          case "images":
+            if (creating)
+              await tx.image.create({
+                data: { ...base, ...change.values }
+              });
+            else
+              await tx.image.update({ where, data: change.values });
+            break;
+        }
+      })));
+    },
+    async deleteExported(domain, owner, id) {
+      const where = { id, userId: owner, status: "EXPORTED" };
+      switch (domain) {
+        case "articles":
+          return (await prisma.article.deleteMany({ where })).count;
+        case "notes":
+          return (await prisma.note.deleteMany({ where })).count;
+        case "books":
+          return (await prisma.book.deleteMany({ where })).count;
+        case "images":
+          return (await prisma.image.deleteMany({ where })).count;
+      }
+      throw new Error("Unsupported content domain");
+    },
+    async isMediaReferenced(path) {
+      return await prisma.image.count({ where: { path } }) > 0;
+    }
+  };
+}
+
+// ../infrastructure/dist/batch/import-media-store.js
+function createImportMediaStore(storage, processor) {
+  return {
+    async put(domain, path, bytes) {
+      const target = storage[domain];
+      try {
+        await target.getImageOrThrow(path, false);
+      } catch {
+        await target.uploadImage(path, bytes, false);
+      }
+      await target.uploadImage(path, await processor.createThumbnail(bytes, 192, 192), true);
+    },
+    async removeImage(path) {
+      await storage.images.deleteImage(path, false);
+      await storage.images.deleteImage(path, true);
+    }
+  };
+}
+
+// ../infrastructure/dist/shared/books-storage-service.js
+var ORIGINAL_BOOK_IMAGE_PATH = "books/original";
+var THUMBNAIL_BOOK_IMAGE_PATH = "books/thumbnail";
+function createBooksStorageService(minioClient, bucketName) {
+  return createStorageService(minioClient, bucketName, {
+    originalPrefix: ORIGINAL_BOOK_IMAGE_PATH,
+    thumbnailPrefix: THUMBNAIL_BOOK_IMAGE_PATH
+  });
+}
+
+// ../infrastructure/dist/shared/minio-storage-service.js
+function createImagesStorageService(minioClient, bucketName) {
+  return createStorageService(minioClient, bucketName, {
+    originalPrefix: "images/original",
+    thumbnailPrefix: "images/thumbnail"
+  });
+}
+
+// ../infrastructure/dist/system-clock.js
+var systemClock = { now: () => /* @__PURE__ */ new Date() };
+
+// src/lib/run-content-import.ts
+async function runContentImport(domain, source) {
+  const databaseUrl = process.env.DATABASE_URL;
+  const owner = process.env.USERNAME_TO_EXPORT;
+  if (!databaseUrl || !owner)
+    throw new Error("DATABASE_URL and USERNAME_TO_EXPORT are required.");
+  const dryRun = process.argv.includes("--dry-run");
+  const prisma = createPrismaClient(databaseUrl);
+  const notification = createPushoverService({
+    url: process.env.PUSHOVER_URL ?? "",
+    userKey: process.env.PUSHOVER_USER_KEY ?? "",
+    appToken: process.env.PUSHOVER_APP_TOKEN ?? ""
+  });
+  try {
+    const mediaDomain = domain === "images" || domain === "books";
+    const bucket = process.env.MINIO_BUCKET_NAME;
+    if (mediaDomain && !dryRun && !bucket)
+      throw new Error("MINIO_BUCKET_NAME is required.");
+    const client = mediaDomain && !dryRun ? createMinioClient() : void 0;
+    const media = client && bucket ? createImportMediaStore(
+      {
+        images: createImagesStorageService(client, bucket),
+        books: createBooksStorageService(client, bucket)
+      },
+      sharpImageProcessor
+    ) : void 0;
+    const summary = await synchronizeContent(
+      domain,
+      owner,
+      source(process.env.S_CONTENTS_PATH ?? process.cwd()),
+      {
+        repository: createContentImportRepository(prisma),
+        clock: systemClock,
+        media
+      },
+      {
+        dryRun,
+        onProgress: (event) => console.log(
+          `${dryRun ? "[dry-run] " : ""}${event.action}: ${event.key}`
+        )
+      }
+    );
+    console.log(summary);
+    await notification.notifyInfo(`ingest-${domain} completed`, { caller: `ingest-${domain}` }).catch((error) => console.error("\u901A\u77E5\u5931\u6557:", error));
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+    await notification.notifyError(`ingest-${domain} failed`, { caller: `ingest-${domain}` }).catch((notifyError) => console.error("\u901A\u77E5\u5931\u6557:", notifyError));
+  } finally {
+    await prisma.$disconnect();
+  }
+}
+
+export {
+  makeISBN,
+  sharpImageProcessor,
+  runContentImport
+};

package/dist/chunk-7PVU2Z32.js

@@ -0,0 +1,71 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../notification/dist/errors.js
+var NotificationError = class extends Error {
+  constructor(message = "notificationSend") {
+    super(message);
+    this.name = "NotificationError";
+  }
+};
+
+// ../notification/dist/pushover.js
+var PushoverService = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Sends a message to the Pushover API.
+   *
+   * @param message - The message to send
+   * @param priority - The priority level (-1 = low, 0 = normal, 1 = high)
+   *
+   * @internal
+   */
+  async sendMessage(message, priority = 0) {
+    try {
+      const body = new URLSearchParams({
+        token: this.config.appToken,
+        user: this.config.userKey,
+        message,
+        priority: String(priority)
+      });
+      const result = await fetch(this.config.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body
+      });
+      if (!result.ok) {
+        throw new NotificationError();
+      }
+    } catch (error) {
+      if (error instanceof NotificationError) {
+        console.error(`[NotificationService] Failed to send notification: ${error.message}`);
+      } else {
+        console.error("[NotificationService] Unknown error occurred while sending notification:", error);
+      }
+    }
+  }
+  async notifyError(message, context) {
+    const enrichedMessage = `[ERROR] ${context.caller}: ${message}`;
+    await this.sendMessage(enrichedMessage, 1);
+  }
+  async notifyWarning(message, context) {
+    const enrichedMessage = `[WARN] ${context.caller}: ${message}`;
+    await this.sendMessage(enrichedMessage, 0);
+  }
+  async notifyInfo(message, context) {
+    const enrichedMessage = `[INFO] ${context.caller}: ${message}`;
+    await this.sendMessage(enrichedMessage, -1);
+  }
+};
+function createPushoverService(config) {
+  return new PushoverService(config);
+}
+
+// ../notification/dist/web-push.js
+import webPush from "web-push";
+
+export {
+  createPushoverService
+};

package/dist/chunk-AJMTRCPJ.js

@@ -0,0 +1,15 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// src/lib/glob-paths.ts
+import { glob } from "node:fs/promises";
+async function globPaths(pattern, options = {}) {
+  const paths = [];
+  for await (const path of glob(pattern, options)) {
+    paths.push(path);
+  }
+  return paths.toSorted((left, right) => left.localeCompare(right, "en"));
+}
+
+export {
+  globPaths
+};